askirmas / postcss-d-ts

import {extractDefaults, regexpize} from './utils'

import {

  $exists, $unlink, readlineSync

} from './fs'

import schema = require("./schema.json")

import type {Options} from './options.types'

import replaceMultiplicated = require('./replaceMultiplicated')

import collector = require('./collector')

import rewrite = require('./rewrite')

import type {InternalOptions, WithSource} from './$defs.types'

type Opts = Required<Options>

const {keys: $keys} = Object

, defaultOptions = extractDefaults(schema) as Opts

, {

  title,

  signature,

  templateEol,

  properties: {template: {$comment: templatePath}}

} = schema

, defaultTemplate = readlineSync(resolve(__dirname, templatePath), templateEol),

creator8 = (opts?: Options) => {

  const options = makeOpts(opts)

  return {

    postcssPlugin: title,

    prepare: (result: {

      warn: (arg: string) => any

      root: WithSource

    }) => {

      //TODO #12 template update check

      /* istanbul ignore next `source === undefined` for manually created node with `.decl` */

      if (!result.root?.source?.input.file)

        return {}

      try {

        const warn = optsCheck(options)

        warn && result.warn(warn)

      } catch ({message}) {

        // TODO throw error

        result.warn(message)

        return {}

      }

      // https://jsbench.me/q5km8xdgbb

      const identifiers: Record<string, true> = {}

      return {

        RuleExit: collector(identifiers, options),

        RootExit: writer(identifiers, options)

      }

    }

  } //as Plugin

}

creator8.postcss = true

export = creator8

function optsCheck({

  destination,

  identifierParser

}: {destination: any} & Pick<InternalOptions, "identifierParser">) {

  if (!(destination === false || destination !== null && typeof destination === "object"))

    throw new Error("Destination is of wrong type")

  if (!identifierParser.flags.includes('g'))

    return 'identifierParser without global flag may take only first occurance'

  return

}

function makeOpts(opts?: Options) {

  const options = !opts ? defaultOptions : {...defaultOptions, ...opts}

  , {

    eol,

    destination,

    //TODO several keywords?

    identifierKeyword,

    identifierMatchIndex,

    identifierCleanupReplace

  } = options

  return {

    eol,

    destination,

    identifierKeyword,

    identifierMatchIndex,

    identifierCleanupReplace,

    ...internalOpts(options)

  }

}

function internalOpts({

  eol,

  template: templatePath,

  identifierPattern: cssP,

  identifierCleanupPattern: escapedP,

  allowedAtRules: atRules,

  checkMode

}: Pick<Opts, "eol"|"template"|"identifierPattern"|"identifierCleanupPattern"|"allowedAtRules"|"checkMode">) :InternalOptions {

  const identifierParser = regexpize(cssP, "g")

  , identifierCleanupParser = regexpize(escapedP, "g")

  //TODO check `templatePath === ""`

  , templateContent = typeof templatePath === "string"

  // TODO not sync

  ? readlineSync(templatePath, eol)

  : defaultTemplate

  , allowedAtRuleNames = new Set(atRules)

  return {

    identifierParser,

    identifierCleanupParser,

    templateContent,

    allowedAtRuleNames,

    checkMode: checkMode ?? process.env.NODE_ENV === "production"

  }

}

}